import xlrd
import clases as cs
import logging
from psrgen import generar_inscritos as gs
import itertools
from numpy import *

''' 
En este archivo va todo lo que agarre un archivo y lo convierta en algo
'''

    
#Recordar usar .xls , xlrd no soporta .xlsx. Retorna un arreglo con Carreras.
def ParseXLS(path):
    wb = xlrd.open_workbook(path)
    carreras=[crear_carrera(wb,s) for s in xrange(wb.nsheets)]
    return carreras

#Para el XLS
def crear_carrera(wb,s):
    aux = wb.sheet_by_index(s)
    carrera_nueva=cs.Carrera(aux.name)
        #carreras.append(carrera_nueva)
    for c in xrange(aux.ncols):
        semestre=cs.Semestre(c+1)
        carrera_nueva.agregarSemestre(semestre) 
        for i in xrange(len(aux.col_values(c))-1):
            raw_string = aux.cell(i+1,c).value;
            splitted = raw_string.split(';')
            nombre = splitted[0]
            inscritos = gs(int(splitted[1]))
            tasa = int(splitted[1])
            ramo_nuevo=cs.Ramo(nombre, inscritos, tasa)
            ramo_nuevo.CS=(s,c+1)
            semestre.agregarRamos(ramo_nuevo) 
    return carrera_nueva

#Toma los clusters y los formatea para que lo lea el patronGenerator en el archivo p.txt
def clustersToFile(clusters, path):
	f = open("p.txt","w")
	for i in xrange(0,len(clusters)):
		f.write("%i %i %i\n") % (i, i, clusters[i].totalInscritos())
	f.close()
		

'''
Falta generalizar para n salas de tipo n' con archivo de clusters p.
'''
class PatronGenerator(object):

    def __init__(self):
        #clustersFilePath = raw_input("Insertar nombre del archivo con clusters")
        #logging.basicConfig(filename='LOG.log',level=logging.DEBUG)        
        clustersFilePath = "p.txt"
        archivoClusters = self.leerPath(clustersFilePath)
        
        self.clusters = {}
        self.output = {}
        self.cantTipoSalas =3
        self.salas = (30,45,70)
        self.cantSalas = (12,17,7)
        self.totalPatrones=12*17*7
        self.patronesEnOutput = []
        self.todoPatrones = []
        
        for s in archivoClusters:
            clusterSplit = s.split(',')
            clust = clusterSplit[0]
            alumns = clusterSplit[1]
            self.clusters[clust]=alumns
            self.output[clust]=""
        for i in xrange(self.cantSalas[0]+1):
            for j in xrange(self.cantSalas[1]+1):
                for k in xrange(self.cantSalas[2]+1):
                    self.todoPatrones.append((i,j,k))
                    #self.patronesEnOutput.append(False)
        for i in itertools.repeat(None, self.totalPatrones):
            self.patronesEnOutput.append(False)
        self.todoPatrones=tuple(self.todoPatrones)  
        
    def leerPath(self, path):
        _file = open(path,"r")
        archivo = []
        archivo.append(_file.readline())
        while archivo[len(archivo)-1]!="":
            archivo.append(_file.readline())
        _file.close()
        archivo = archivo[0:len(archivo)-1]
#        archivo=_file.readlines()
        return archivo
    
    def prodPunto(self, vect1):
        result = 0        
        for i in xrange(self.cantTipoSalas) :
            result += vect1[i]*self.salas[i]
        return result
    
    def generarPatrones(self):
            #Primero listar todos los patrones posibles.
            #Luego, ver cuales cumplen el requisito de alumnos.
            #Luego, optimizar segun Paretto.      
        for  clust in self.clusters:
            self.output[clust] = self.generarPatronActual(self.clusters[clust])
        for v in self.output:
            for i in self.output[v]:
                self.patronesEnOutput[i] = True
            #logging.info("cluster generado: "+ str(clust)+" "+ str(self.output[clust]))
        #self.generarOutputFile();
		
    
    def generarPatronActual(self, size):
        patronesAceptados = []
        size=int(size)
        for _ in itertools.repeat(None, self.totalPatrones):
            patronesAceptados.append(False)
        #print patronesAceptados
        #print self.todoPatrones
        for i in xrange(len(patronesAceptados)):
            if self.prodPunto(self.todoPatrones[i]) >= size:
                patronesAceptados[i] = True                
        for j,pat in enumerate(patronesAceptados):
            if (pat):   # Ultimo
                for i in xrange(j):
                    if (patronesAceptados[i]): # Comparando con
                        #a=self.todoPatrones[i][0] <= self.todoPatrones[j][0]
                        #b= self.todoPatrones[i][1] <= self.todoPatrones[j][1]
                        #c=self.todoPatrones[i][2] <= self.todoPatrones[j][2]
                        if (self.todoPatrones[i][0] <= self.todoPatrones[j][0] and self.todoPatrones[i][1] <= self.todoPatrones[j][1] and self.todoPatrones[i][2] <= self.todoPatrones[j][2]):
                            patronesAceptados[j] = False  
        patrones = []
        for i,pat in enumerate(patronesAceptados):
            if (pat):
                patrones.append(i)
        return patrones

    #Retorna una lista con patrones con la forma [s,m,l]
    def patronesOut(self):
        out=[]
        for i in xrange(len(self.patronesEnOutput)):
            if self.patronesEnOutput[i]:
                out.append(self.todoPatrones[i])
        return out           
                
    
    def generarOutputFile(self):
        sr = open("patrones.inc","w")
        for v in self.output:
            for i in self.output[v]:
                self.patronesEnOutput[i] = True
        sr.write("/\n");
        for i in xrange(len(self.patronesEnOutput)):
            if (self.patronesEnOutput[i]):
                sr.write("p%i\n" % (i+1))
        sr.write("/\n")
        sr.close()
        sr1 = open("N.inc","w")
        for  kv in self.output:
            for i in self.output[kv]:
                sr1.write("N(\"%s\",\"p%i\") = 1;\n" % (str(kv),i+1))
        sr1.close()
        sr3 = open("QN.inc","w")
        for  i in xrange(len(self.patronesEnOutput)):
            if (self.patronesEnOutput[i]):
                sr3.write("QN(\"p%i\",\"pequena\")=%s;\n" % (i+1, str(self.todoPatrones[i][0])))
                sr3.write("QN(\"p%i\",\"mediana\")=%s;\n" % (i+1,str(self.todoPatrones[i][1])))
                sr3.write("QN(\"p%i\",\"grande\")=%s;\n" % (i+1,str(self.todoPatrones[i][2])))
        sr3.close();  
        
        #    StreamWriter sr2 = new StreamWriter("output.txt");
        #    foreach (KeyValuePair<int, List<int>> kv in this.output)
        #    {
        #        foreach (int i in kv.Value)
        #        {
        #            sr2.WriteLine(kv.Key + " {" + this.todoPatrones[i][0] + "," + this.todoPatrones[i][1] + "," + this.todoPatrones[i][2] + "}");
        #        }
        #    }
        #    sr2.Close();
        #    */


        
